﻿#define _CRT_SECURE_NO_WARNINGS 1

#include<iostream>
using namespace std;//展开std中的所有成员

//
//int main()
//{
//	cout << "hello, world!" << endl;
//	return 0;
//}

//#include<stdio.h>
//#include<stdlib.h>
//
////int rand = 10; // 重定义问题
//
//int a = 10;
//namespace zh
//{
//	int rand = 15;
//	int a = 5;
//}
//
//int main()
//{
//	int a = 1;
//	printf("%d\n", zh::rand);//::域作用限定符
//	printf("%p\n", rand);
//
//	cout << a << endl;//1
//	cout << ::a << endl;//10
//	cout << zh::a << endl;//5
//
//	return 0;
//}

//////////////////////////////////////////////////////////


//域也可以嵌套

//namespace zh
//{
//	int a = 10;
//
//	namespace xd
//	{
//		int a = 5;
//	}
//
//	namespace gi
//	{
//		int a = 1;
//	}
//}
//
////using zh::xd::a;
//using namespace zh::xd;
////using zh::a;
//
//int main()
//{
//	//cout << a << endl;//5
//
//	cout << a << endl;//5 xd 的 a
//	cout << zh::a << endl;//10
//	cout << zh::xd::a << endl;//5
//	cout << zh::gi::a << endl;//1
//
//	return 0;
//}

////////////////////////////////////////

// 多⽂件中可以定义同名namespace，他们会默认合并到⼀起，就像同⼀个namespace⼀样
//逻辑上

//#include"Stack.h"
//
//typedef int STDataType;
//typedef struct Stack
//{
//	STDataType a[10];
//	int top;
//	int capacity;
//}ST;
//void STInit(ST* ps) {}
//
//int main()
//{
//	// 调用全局的
//	ST st1;
//	STInit(&st1);
//	printf("%d\n", sizeof(st1));
//
//	// 调用bit namespace的
//	zh::ST st2;
//	STInit(&st2);
//	printf("%d\n", sizeof(st2));
//	return 0;
//}

//////////////////////////////////////////////////////


//int main()
//{
//	int a = 0;
//	double b = 0.1;
//	char c = 'x';
//
//	//自动识别 输出不需要指定格式
//	cout << a << " " << b << " " << c << endl;
//
//	//输入也可以自动识别
//	cin >> a >> b >> c;
//	cout << a << " " << b << " " << c << endl;
//	return 0;
//
//}

//int main()
//{
//	// 在io需求比较高的地方，如部分大量输入的竞赛题中，加上以下3行代码
//	// 可以提高C++IO效率
//	ios_base::sync_with_stdio(false);
//	cin.tie(nullptr);
//	cout.tie(nullptr);
//
//	return 0;
//}

/////////////////////////////////////////////////

//缺省变量

// 全缺省
//void Func1(int a = 1, int b = 2, int c = 3)//C++规定半缺省参数必须从右往左依次连续缺省，不能间隔跳跃给缺省值
//{
//	cout << "a = " << a << endl;
//	cout << "b = " << b << endl;
//	cout << "c = " << c << endl << endl;
//}
//
//// 半缺省
//void Func2(int a, int b = 1, int c = 2)
//{
//	cout << "a = " << a << endl;
//	cout << "b = " << b << endl;
//	cout << "c = " << c << endl << endl;
//}
//
//int main()
//{
//	// 没有传参时，使用参数的默认值
//	// 传参时，使用指定的实参
//	//C++规定必须从左到右依次给实参，不能跳跃给实参
//	//函数声明和定义分离时，缺省参数不能在函数声明和定义中同时出现，规定必须函数声明给缺省值。
//	Func1();
//	Func1(10);
//	Func1(10, 20);
//	Func1(10, 20, 30);
//
//	//Func2();
//	Func2(10);
//	Func2(10, 20);
//	Func2(10, 20, 30);
//
//	return 0;
//}

///////////////////////////////////////////

//函数重载
//在同⼀作⽤域中出现同名函数 但要求同名函数的形参不同，可以是参数个数不同或者类型不同。

// 1、参数类型不同


//void Swap(int* px, int* py)
//{}
//
//void Swap(double* px, double* py)
//{}
//
//// 2、参数个数不同
//void f()
//{
//	cout << "f()" << endl;
//}
//void f(int a)
//{
//	cout << "f(int a)" << endl;
//}
//
//// 3、参数类型顺序不同
//void f(int a, char b)
//{
//	cout << "f(int a,char b)" << endl;
//}
//
//void f(char b, int a)
//{
//	cout << "f(char b, int a)" << endl;
//}
//
//void f1()
//{
//	cout << "f()" << endl;
//}
//
//void f1(int a = 1)
//{
//	cout << "f(int a)" << endl;
//}

//上面两个函数构成重载，参数个数不同
//但是调用会出问题

// 返回值不同不能作为重载条件，因为调用时也无法区分

///////////////////////////////////////////////////

//引用
//int main()
//{
//	int a = 0;
//	// 引用：b和c是a的别名
//	int& b = a;
//	int& c = a;
//
//
//	// 也可以给别名b取别名，d相当于还是a的别名
//	int& d = b;
//	++d;
//
//	// 这里取地址我们看到是一样的
//	cout << &a << endl;
//	cout << &b << endl;
//	cout << &c << endl;
//	cout << &d << endl;
//	return 0;
//}
//
////传ab过来，rx ry还是对a b操作
//void Swap(int& rx, int& ry)
//{
//	int tmp = rx;
//	rx = ry;
//	ry = tmp;
//}

//int main()
//{
//	int a = 10;
//	//编译报错：“ra”: 必须初始化引用
//	int& ra = a;
//
//	////空引用
//	//int* ptr = NULL;
//	//int& rb = *ptr;
//	//rb++;
//	//不存在空值引用
//
//	return 0;
//}

//函数模板
//template<class T>
//void func(const T& val)
//{
//
//}
//
//int main()
//{
//	// 引用的时候权限可以缩小，但是不能放大
//	const int a = 10;
//	int rd = a;
//	//int& ra = a;
//
//	const int& ra = a;
//
//	//权限缩小
//	int b = 20;
//	const int& rb = b;
//	b++;
//
//	const int& rc = 30;
//	const int& rd = a + b;
//	//右边是临时对象，必须用const
//
//	double d = 13.14;
//	int i = d;
//	//涉及类型转换，d强转后的值是临时变量，要用const
//	const int& ri = d;
//	double& rd = d;
//
//}

/////////////////////////////////////////

//正确的宏实现
//#define ADD(x, y) ((x) + (y))
// 为什么不能加分号?
// 为什么要加外面的括号?
// 为什么要加里面的括号?
//保证优先级
//int main()
//{
//	cout << ADD(1, 2) * 5 << endl;
//
//	int x = 1, y = 2;
//	ADD(x & y, x | y);// ->(x&y + x|y)
//	//+的优先级比& | 高，所以里面也要加括号
//
//	return 0;
//}

//namespace Moss
//{
//	int a = 5;
//	namespace ship//命名空间的嵌套
//	{
//		int b = 10;
//	}
//}
//int a = 10;
//
//int main()
//{
//
//
//	printf("%d\n", ::a);//全局域
//	printf("%d\n", Moss::a);//Moss域
//	return 0;
//}

//namespace Moss
//{
//	int a = 1;
//	int b = 2;
//}
//
//using Moss::b;//展开某个成员
//
//namespace Mikey
//{
//	int c = 3;
//	int d = 4;
//}
//using namespace Mikey;//展开命名空间所有成员
//
//int main()
//{
//	printf("%d\n", Moss::a);//指定命名空间访问
//	printf("%d\n", b);
//	printf("%d\n", c);
//	printf("%d\n", d);
//	return 0;
//}

//#include<iostream>
//
//using namespace std;//展开std的所有成员，以便于练习
//
//int main()
//{
//	int a = 10;
//	double  d = 3.14;
//	char s = 'f';
//
//	cout << a << endl;
//	cout << d << endl;
//	cout << s << endl;
//	cout << endl;
//	//打印 a d s
//
//	cin >> a;
//	cin >> d;
//	cin >> s;
//	cout << endl;
//	//键盘输入
//
//	cout << a << endl;
//	cout << d << endl;
//	cout << s << endl;
//	cout << endl;
//	//打印输入后的值
//
//	return 0;
//}

void F(int x)
{
	cout << "F(int x)" << endl;
}

void F(int* ptr)
{
	cout << "F(int* ptr)" << endl;
}

int main()
{
	F(0);

	F(NULL);

	
	//F(nullptr);
	return 0;
}